package gob.cgr.web.sgrh.managed;



import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.InputStream;
import java.util.List;
import gob.cgr.sgrh.ejb.entidad.Documento;
import gob.cgr.sgrh.ejb.entidad.Legajo;
import gob.cgr.sgrh.ejb.entidad.MovimientoDePersonal;
import gob.cgr.sgrh.ejb.entidad.Personal;
import gob.cgr.sgrh.ejb.entidad.SeccionLegajo;
import gob.cgr.sgrh.ejb.entidad.SolicitudLegajo;
import gob.cgr.web.sgrh.service.SigerhService;
import gob.cgr.web.sgrh.util.FTPUtil;
import gob.cgr.web.sgrh.util.Utilitario;
import javax.annotation.PostConstruct;
import javax.faces.bean.ManagedBean;
import javax.faces.bean.ViewScoped;
import javax.faces.context.FacesContext;
import javax.faces.event.ActionEvent;
import javax.inject.Inject;
import org.primefaces.event.FileUploadEvent;
import org.primefaces.event.RowEditEvent;
import org.primefaces.model.DefaultStreamedContent;
import org.primefaces.model.StreamedContent;
import org.primefaces.model.UploadedFile;


@ManagedBean
@ViewScoped
public class LegajoMB {

	
	@Inject
	private SigerhService service;
	private List<Legajo> legajos;
	private List<SeccionLegajo> secciones;
	private Personal colaborador;
	private Legajo legajo;
	private SeccionLegajo seccionSelected;
	private UploadedFile	file;
	private List<Documento> tipoDocumentos;
	private StreamedContent fotoPersonal;
	private String gerencia;
	private String puesto;
	private String fechaIngreso;
	private Legajo legajoSelected;
	private String motivoRechazo;
	private String motivoSolicitado;
	private SolicitudLegajo solicitud;
	
	public LegajoMB() {
		// TODO Auto-generated constructor stub
	}
	
	@PostConstruct
	public void init(){
		checkColaborador();
		System.out.println("desde legajo, colaborador es :"+colaborador);
		cargarDatosAdicionales();
		if(secciones==null)
			secciones=service.listarSeccionesLegajo();
		listarLegajos();
		seccionSelected=secciones.get(0);
		System.out.println("seccionSelected "+seccionSelected);
		if(tipoDocumentos==null){
			tipoDocumentos=service.listarDocumentosPorTipo("LEGAJO");
		}
		//fotoPersonal=loadFoto();
		nuevoLegajo();
	}

	private void listarLegajos(){
		if(colaborador!=null)
			legajos=service.listarLegajoPersonal(colaborador.getIdPersonal(), 1); // por defecto se cargara la primera seccion
		
	}
	
	public void nuevoLegajo(){
		legajo=new Legajo();
		legajo.setIdPersonal(colaborador);
		legajo.setIdDocumento(new Documento());
		file=null;
	}
	
	
	public void check(){
		checkColaborador();
		if (colaborador == null) {
			System.out
					.println("ups, esta pagina se ha cargado sin ser llamada desde la busqueda");
			FacesContext fc = FacesContext.getCurrentInstance();
			/*fc.getApplication().getNavigationHandler()
					.handleNavigation(fc, "faces-redirect=true", "legajoVirtual");*/
			//Map<K, V> m=new HashMap<String,String[]>() 
			
						
			try {
				FacesContext.getCurrentInstance().getExternalContext().redirect("legajoBusqueda.jsf");
			} catch (Exception e) {
				// TODO: handle exception
				System.out.println("no pude redireccionar");
			}
			}
		
	}
	
	
	public void actualizarLegajo(){
		if(file==null){
			Utilitario.mostrarMensajeAlerta("No ha elegido ningun archivo");
			return;
		}
	try {
		String nombreArchivo=guardarArchivo();
			if(nombreArchivo==null){
				Utilitario.mostrarMensajeAlerta("Ocurrio un error al guardar el archivo");
				return;
			}
			legajo.setIdPersonal(colaborador);
			legajo.setArchivo(nombreArchivo);
			legajo.setIdSeccionLegajo(seccionSelected);
			service.actualizarLegajo(legajo);
			Utilitario.mostrarMensajeExito("El legajo se ha actualizado correctamente");
			nuevoLegajo();
			listarLegajos();
		} catch (Exception e) {
			// TODO: handle exception
			Utilitario.mostrarMensajeAlerta("No se pudo actualizar el legajo");
		}
	}
	
	public void eliminarLegajo(ActionEvent event){
		try {
			eliminarArchivo(legajoSelected.getArchivo());
			service.eliminarLegajo(legajoSelected);
			if(legajoSelected.getIdSolicitud()!=null){
				SolicitudLegajo s=service.obtenerSolicitudLegajo(legajoSelected.getIdSolicitud());
				s.setMotivoRechazo(motivoRechazo);
				s.setEstado("A");
				System.out.println("actualizado la solicitud del legajo tambien");
				service.actualizarSolicitudLegajo(s);
			}
			listarLegajos();
			Utilitario.mostrarMensajeExito("La operacion se ha realizado correctamente");
			legajoSelected=null;
		} catch (Exception e) {
			// TODO: handle exception
			e.printStackTrace();
			Utilitario.mostrarMensajeAlerta("Hubo un error al eliminar el legajo :"+e.getMessage());
		}
		
		
	}
		
	private boolean eliminarArchivo(String filename){
		/*String carpetaPersonal=Utilitario.getCarpetaLegajo()+legajo.getIdPersonal().getCodigoPersonal();
		File f = new File(carpetaPersonal+"/"+ filename); 
		try {
			if(f.exists())
				return f.delete();
		} catch (Exception e) {
			// TODO: handle exception
			return false;
		}*/
	FTPUtil ftp=new FTPUtil();
	ftp.connect();
	boolean res=ftp.removeLegajo(legajo.getIdPersonal().getCodigoPersonal(), filename);
		return res;
	}
	
	private void cargarSeccion(){
		legajos=service.listarLegajoPersonal(colaborador.getIdPersonal(), seccionSelected.getIdSeccionLegajo());
		legajoSelected=null;
		nuevoLegajo();
	}
	
	public List<Legajo> getLegajos() {
		return legajos;
	}

	public void setLegajos(List<Legajo> legajos) {
		this.legajos = legajos;
	}

	public List<SeccionLegajo> getSecciones() {
		return secciones;
	}

	public void setSecciones(List<SeccionLegajo> secciones) {
		this.secciones = secciones;
	}

	public Personal getColaborador() {
		return colaborador;
	}

	public void setColaborador(Personal colaborador) {
		System.out.println("seteando el colaborador "+colaborador);
		this.colaborador = colaborador;
	}

	public Legajo getLegajo() {
		return legajo;
	}

	public void setLegajo(Legajo legajo) {
		this.legajo = legajo;
	}

	public SeccionLegajo getSeccionSelected() {
		return seccionSelected;
	}

	public void setSeccionSelected(SeccionLegajo seccionSelected) {
		this.seccionSelected = seccionSelected;
		cargarSeccion();
	}
	
	public void handleFileUpload(FileUploadEvent e) {
		try {
			setFile(e.getFile());
			//foto = new DefaultStreamedContent(file.getInputstream());// ,
		}catch (Exception ex) {
			System.out.println(ex.getMessage());
		}
	}
	
	private String guardarArchivo(){
		if(file==null)return null;
		FTPUtil clientFTP=new FTPUtil();
		try {
			clientFTP.connect();
			String carpetaPersonal=Utilitario.getCarpetaLegajo()+legajo.getIdPersonal().getCodigoPersonal();
			
			if(new File(carpetaPersonal).exists()==false){
				System.out.println("creando carpeta "+carpetaPersonal+"porque no exixtia ");
				new File(carpetaPersonal).mkdir();
				
			}
			boolean r=clientFTP.crearCarpeta(legajo.getIdPersonal().getCodigoPersonal());
			System.out.println("se creo en el FTP la carpeta ?"+r);
			
			int numChars=file.getFileName().length() - (file.getFileName().lastIndexOf(".")+1);
			String extension=Utilitario.izquierda(file.getFileName(),numChars);
			String newFileName =generateNumber(legajo)+"."+extension;
			System.out.println("fileName:"+newFileName);
			//File fileAguardar = new File(carpetaPersonal+"/"+ newFileName);
			File fileAguardar = new File(newFileName);
			System.out.println("file " + fileAguardar.getAbsolutePath());
			FileOutputStream fos = new FileOutputStream(fileAguardar);
			InputStream is = file.getInputstream();
			int BUFFER_SIZE = 8192;
			byte[] buffer = new byte[BUFFER_SIZE];
			int a;
			while (true) {
				a = is.read(buffer);
				if (a < 0)
					break;
				fos.write(buffer, 0, a);
				fos.flush();
			}
			fos.close();
			is.close();
			
			clientFTP.connect();
			clientFTP.guardarLegajo(fileAguardar,null,legajo.getIdPersonal().getCodigoPersonal());
			clientFTP.disconnect();
			fileAguardar.delete();
			System.out.println("se guardo el legajo ");
			return newFileName;
		} catch (Exception e) {
			// TODO: handle exception
			System.out.println("error al guardar el legajo " + e.getMessage());
			return null;
		}
		
		
		
	}
	
	private String generateNumber(Legajo leg){
		StringBuilder prefijo= new StringBuilder("S"+seccionSelected.getNumero()+"-");
		for(Documento d:tipoDocumentos){
			if(leg.getIdDocumento().getIdDocumento()==d.getIdDocumento()){
				prefijo.append(d.getDescripcion().substring(0,3));
				break;
			}
		}
		int num=1;
		int indexLast=-1;
		for(Legajo l:legajos){
			if(l.getArchivo().startsWith(prefijo.toString()))
				indexLast++;
		}
		
		
		if(indexLast>-1){
			String nombreDoc=legajos.get(indexLast).getArchivo();
			int numChars=nombreDoc.length() - (nombreDoc.lastIndexOf(".")+1);
			String nro=Utilitario.izquierda(nombreDoc,numChars+4);
			nro=nro.substring(0,3);
			num=Integer.parseInt(nro)+1;
		}
		prefijo.append(String.format("%03d", num));
		return prefijo.toString();
	}
	
	
	public UploadedFile getFile() {
		return file;
	}

	public void setFile(UploadedFile file) {
		this.file = file;
	}

	public List<Documento> getTipoDocumentos() {
		return tipoDocumentos;
	}

	public void setTipoDocumentos(List<Documento> tipoDocumentos) {
		this.tipoDocumentos = tipoDocumentos;
	}
	
	public String verLegajo(){
		
		Utilitario.getFlashScope().put("colaborador", colaborador);
		System.out.println("setted in flash scope :"+colaborador +" retornando para ver Legajo");
		return "verLegajo";
	}
	
	private void checkColaborador(){
		if(colaborador==null){
			if(Utilitario.getFlashScope().get("colaborador")!=null)
			colaborador=(Personal)Utilitario.getFlashScope().get("colaborador");
		}
	}
	
	private void cargarDatosAdicionales(){
	
	if(colaborador==null) return;	
	for(MovimientoDePersonal m:	service.listarMovimientosPersonal(colaborador.getIdPersonal())){
		gerencia=m.getIdUnidadOrganica().getNombreUnidad();
		puesto=m.getIdPuesto().getNombre();
		setFechaIngreso(String.format("%1$td-%1$tb-%1$tY",m.getIngreso()));
		
		break;
	}
	
	}

	
	
	public StreamedContent getFotoPersonal() {
		FacesContext context = FacesContext.getCurrentInstance();
		/*if(context.getRenderResponse()){
			System.out.println("render response");
			return new DefaultStreamedContent();
		}
		else{
			System.out.println("browswer request");*/
		return fotoPersonal;
		
		//}
	}

	public void setFotoPersonal(StreamedContent fotoPersonal) {
		this.fotoPersonal = fotoPersonal;
	}

	public String getGerencia() {
		return gerencia;
	}

	public void setGerencia(String gerencia) {
		this.gerencia = gerencia;
	}

	public String getPuesto() {
		return puesto;
	}

	public void setPuesto(String puesto) {
		this.puesto = puesto;
	}
	
	public Legajo getLegajoSelected() {
		return legajoSelected;
	}

	public void setLegajoSelected(Legajo legajoSelected) {
		System.out.println("colocando el legajo selected:::");
		this.legajoSelected = legajoSelected;
	}

	/*private StreamedContent loadFoto() {
		if (colaborador.getFoto() != null)
			try {
				System.out.println("cargando la foto original");
				File f = new File(Utilitario.getCarpetaFoto()
						+ colaborador.getFoto());
				System.out.println("::::cargado la foto original "+f);
				String type=Utilitario.izquierda(colaborador.getFoto(),3);
				InputStream is=new FileInputStream(f);
				StreamedContent sc=new DefaultStreamedContent(is,"image/jpeg");
				return sc;
			} catch (Exception e) {
				// TODO: handle exception
				System.out.println("error al cargar la foto original "
						+ fotoPersonal + "  " + e.getMessage());
				return null;
			}
		return null;
	}*/

	public String getFechaIngreso() {
		return fechaIngreso;
	}

	public void setFechaIngreso(String fechaIngreso) {
		this.fechaIngreso = fechaIngreso;
	}
	
	private String renombrarArchivoLegajo(Legajo leg){
		String carpetaPersonal=Utilitario.getCarpetaLegajo()+legajo.getIdPersonal().getCodigoPersonal();
		String oldName=leg.getArchivo();
		File f = new File(carpetaPersonal+"/"+ oldName); 
		int numChars=oldName.length() - (oldName.lastIndexOf(".")+1);
		String extension=Utilitario.izquierda(oldName,numChars);
		String newName=generateNumber(leg)+"."+extension;
		File f2=new File(carpetaPersonal+"/"+newName);
		
		try {
			f.renameTo(f2);
			FTPUtil ftpUtil=new FTPUtil();
			ftpUtil.connect();
			ftpUtil.renameLegajo(oldName, newName,legajo.getIdPersonal().getCodigoPersonal());
			ftpUtil.disconnect();
			System.out.println("exito en renombrar");
			return newName;
		} catch (Exception e) {
			// TODO: handle exception
			System.out.println("error al renombrar "+e.getMessage());
		}
		return null;
	}
	
	
	
	public StreamedContent verLegajo(Legajo legajo){
		try {
			String fileName=Utilitario.getCarpetaLegajo()+legajo.getIdPersonal().getCodigoPersonal()+"/"+legajo.getArchivo();
			System.out.println("mostrando legajo "+fileName);
			File f=new File(fileName);
			InputStream is=new FileInputStream(f);
			
			DefaultStreamedContent dsc= new DefaultStreamedContent(is,"application/pdf");
			System.out.println("devolviendo "+dsc);
			return dsc;
		} catch (Exception e) {
			System.out.println("error al abrir recurso "+e.getMessage());
			return null;
		}
		
		
	}
	 public void rowEditListener(RowEditEvent event){  
		 final Legajo leg=(Legajo) event.getObject();  
		  System.out.println("legajo sel"+leg);
		  try {
			  if(leg.getIdSolicitud()!=null && leg.isChecked()){
					SolicitudLegajo s=service.obtenerSolicitudLegajo(legajoSelected.getIdSolicitud());
					s.setEstado("V");
					System.out.println("actualizado la solicitud del legajo tambien");
					service.actualizarSolicitudLegajo(s);
					String newName=renombrarArchivoLegajo(leg);
					leg.setArchivo(newName);
					
				}
			  service.actualizarLegajo(leg);
			  Utilitario.mostrarMensajeExito("La operacion se realizo correctamente");
			  legajoSelected=null;
		} catch (Exception e) {
			// TODO: handle exception
			Utilitario.mostrarMensajeAlerta("Hubo un error al actualizar el legajo "+e.getMessage());
		}
		  
		 }

	public void cargarMotivo(Integer idSolicitud){
		System.out.println("legajo selected es"+idSolicitud);
		if(idSolicitud!=null && idSolicitud!=0){
		solicitud=service.obtenerSolicitudLegajo(idSolicitud);
		motivoSolicitado= solicitud.getMotivoSolicitud();
		System.out.println("motivo obtenido "+motivoSolicitado);
		}
	} 
	 
	public String getMotivoRechazo() {
		return motivoRechazo;
	}

	public void setMotivoRechazo(String motivoRechazo) {
		this.motivoRechazo = motivoRechazo;
	}

	public String getMotivoSolicitado() {
		return motivoSolicitado;
	}

	public void setMotivoSolicitado(String motivoSolicitado) {
		this.motivoSolicitado = motivoSolicitado;
	}

	public SolicitudLegajo getSolicitud() {
		return solicitud;
	}

	public void setSolicitud(SolicitudLegajo solicitud) {
		this.solicitud = solicitud;
	} 
	
}
